YES 0.8260000000000001 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]) :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (\vv2 ->
case vv2 of
  x->  if any (eq x) ys then x : [] else []
  _-> []
) xs


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\vv2
case vv2 of
 x → if any (eq xys then x : [] else []
 _ → []

is transformed to
intersectBy0 eq ys vv2 = 
case vv2 of
 x → if any (eq xys then x : [] else []
 _ → []



↳ HASKELL
  ↳ LR
HASKELL
      ↳ CR

mainModule List
  ((intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]) :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (intersectBy0 eq ys) xs

  
intersectBy0 eq ys vv2 
case vv2 of
  x->  if any (eq x) ys then x : [] else []
  _-> []


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case vv2 of
 x → if any (eq xys then x : [] else []
 _ → []

is transformed to
intersectBy00 eq ys x = if any (eq xys then x : [] else []
intersectBy00 eq ys _ = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
HASKELL
          ↳ IFR

mainModule List
  ((intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]) :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (intersectBy0 eq ys) xs

  
intersectBy0 eq ys vv2 intersectBy00 eq ys vv2

  
intersectBy00 eq ys x  if any (eq x) ys then x : [] else []
intersectBy00 eq ys _ []


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if any (eq xys then x : [] else []

is transformed to
intersectBy000 x True = x : []
intersectBy000 x False = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
HASKELL
              ↳ BR

mainModule List
  ((intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]) :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (intersectBy0 eq ys) xs

  
intersectBy0 eq ys vv2 intersectBy00 eq ys vv2

  
intersectBy00 eq ys x intersectBy000 x (any (eq x) ys)
intersectBy00 eq ys _ []

  
intersectBy000 x True x : []
intersectBy000 x False []


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
HASKELL
                  ↳ COR

mainModule List
  ((intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]) :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (intersectBy0 eq ys) xs

  
intersectBy0 eq ys vv2 intersectBy00 eq ys vv2

  
intersectBy00 eq ys x intersectBy000 x (any (eq x) ys)
intersectBy00 eq ys vw []

  
intersectBy000 x True x : []
intersectBy000 x False []


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
HASKELL
                      ↳ Narrow

mainModule List
  (intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a])

module List where
  import qualified Maybe
import qualified Prelude

  intersectBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
intersectBy eq xs ys concatMap (intersectBy0 eq ys) xs

  
intersectBy0 eq ys vv2 intersectBy00 eq ys vv2

  
intersectBy00 eq ys x intersectBy000 x (any (eq x) ys)
intersectBy00 eq ys vw []

  
intersectBy000 x True x : []
intersectBy000 x False []


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_psPs0(vz40, vz3, :(vz50, vz51), vz6, ba) → new_psPs(vz40, vz3, vz51, vz6, ba)
new_psPs(vz40, vz3, vz51, vz6, ba) → new_psPs0(vz40, vz3, vz51, vz6, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
QDP
                            ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_foldr(vz3, vz5, :(vz40, vz41), ba) → new_foldr(vz3, vz5, vz41, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: